The present invention relates to accessing, modifying, and storing documents that may be associated with sandboxed applications on a computing device.
Mobile devices are becoming commonplace for both personal and business settings for many consumers. Like traditional computing devices, mobile devices are susceptible to security breaches. Thus, mobile developers utilize several techniques, such as “sandboxing,” to isolate mobile applications from each other (sandboxing is also used in other computing devices, such as laptops and desktops for increased security and stability). Essentially, in a sandboxed environment, an operating system (OS) for a mobile device isolates each of the applications installed on the device. In other words, an application is only allowed to access or modify data inside of its own “sandbox.” Thus, if there is a corrupt application, it is prevented from harming other applications or accessing/modifying data associated with those other applications. This is especially important because some applications have access to sensitive business or personal information that needs to be protected. Although sandboxing has several advantages, there are also some disadvantages.
For example, many mobile applications do not have integrated editing tools. Thus, users may need to rely on third-party editing applications. As a consequence of sandboxing, documents now need to be explicitly passed between mobile applications using an “Open in” feature or the like to enable editing of documents. FIG. 1 is a diagram illustrating a document being “passed” between two applications, namely, Application 1 and Application 2. Sandbox 102 is associated with Application 1 and sandbox 104 is associated with Application 2. Assume Application 1 does not have editing capabilities but Application 2 does.
During “Event 1,” a user can open a document, say Doc. A, that is associated with sandbox 102 using Application 1. If the user wants to edit Doc. A, he/she cannot do so using Application 1. Thus, the user can use an “Open in” feature in Application 1 to open Doc. A with an editing software, Application 2 (within sandbox 104). Once the user opens and edits the document using Application 2, a new document is created, Doc. A′. In this instance, the original Doc. A is still stored in sandbox 102 while the new document Doc. A′ is opened in Application 2.
During “Event 2,” a user can pass back the edited version of the document Doc. A′ back to Application 1 by using an “Open In” feature in Application 2. The edited version of the document Doc. A′ is subsequently opened in sandbox 102 associated with Application 1. However, once the edited document is passed back, it is saved as another document, Doc. A′, in sandbox 102. Thus, sandbox 102 now contains two versions of the same document, Doc. A and Doc. A′. This is because the Applications 1 and 2 are sandboxed, therefore once a document (in this case a version of a document) is “passed” out of either application, the application no longer has access to the “passed” version of the document and cannot correlate it to an updated document version when that is passed back to the original application. Thus, traditional methods of passing documents between sandboxed applications result in an unnecessary duplication of documents. Users may have to manually replace old version of documents with new, edited versions of documents, which is tedious.
These problems are not as significant if both the source and target application adhere to a common protocol. For example, together with the actual document (Doc A) and its name in the “Open In” feature, the source application can pass an “annotation” to the target application. The annotation can contain an unique identifier that allows the source application to match a received document passed back by the target application when the document is returned in another “Open In” call. For example, the annotation may be a dictionary containing the application-to-application integration uniform resource locator (“URL”) of the document, which is also used to launch the application in order to display the document.
This approach works for in-house applications that are implemented in a way to support the defined annotation protocol. For integration with third-party applications, this does not work because they are not aware of the annotation format and what they are supposed to do with the received annotations. Moreover, third-party application developers may not be inclined to adopt such a protocol if it's made available to them. Thus, a more universal concept is needed.